#include "../headers/queue_link.h"
#include <stdlib.h>
#include <assert.h>
#include <string.h>

int initQueue(Queue * const q,const unsigned int byte_len){
	assert(q!=NULL);
	assert(byte_len>0);
	q->byte_len = byte_len;
	q->head = q->rear = NULL;
	return 1;
}

int	enqueue(Queue* q,void * pvalue){
	assert(q!=NULL);
	assert(pvalue!=NULL);

	//新生成一个空节点
	Node * newer = NULL;
	if((newer = (Node*)malloc(sizeof(Node)))== NULL){
		return 0;
	}

	if((newer->pvalue = malloc(q->byte_len)) == NULL){//空节点中存放值的空间！
		return 0;
	}

	//把值赋值到该内存空间
	memcpy(newer->pvalue,pvalue,q->byte_len);
	newer->next = NULL;

	//插入到链表
	if(q->head == NULL){//第一次插入节点
		q->head = q->rear = newer;
	}else{
		q->rear->next = newer;
		q->rear = newer;
	}

	return 1;
}

int dequeue(Queue *q,void * prest){
	assert(q!=NULL);
	assert(prest!=NULL);

	if(!is_empty(q)){
		memcpy(prest,q->head->pvalue,q->byte_len);
		if(q->head == q->rear){//弹出这个元素后，栈中就没有元素了
			free(q->head->pvalue);
			free(q->head);
			q->head = q->rear = NULL;
		}else{
			Node * tmp = q->head;
			q->head = q->head->next;
			free(tmp->pvalue);
			free(tmp);
		}
	}else{
		return 0;
	}
	return 1;
}
int is_empty(Queue *q){
	if(q->head == NULL){
		return 1;
	}else{
		return 0;
	}
}

int dropQueue(Queue *q){
	Node * tmp = malloc(sizeof(q->byte_len));
	if(!is_empty(q)){
		dequeue(q,tmp);
	}
	free(tmp);
	return 1;
}

void main_queue_link(){
	Queue qlink;
	int i;
	int a[8]={3,8,5,16,9,30,15,22};
	initQueue(&qlink,sizeof(int));

	for(i=0;i<sizeof(a)/sizeof(int);i++){
		enqueue(&qlink,&a[i]);
	}

	while(!is_empty(&qlink)){
		dequeue(&qlink,&i);
		printf("%d\t",i);
	}

	dropQueue(&qlink);
}


//
////if you just use "int" ,only implement queue of positive int!
////if you use elemType ,you can choose!
//void  initQueue(queue *q){
//	q->head=q->rear=NULL;
//	return ;
//}
//
//static int isEmpty(queue *q){
//	if(q->head == NULL)
//		return 1;
//	else
//		return 0;
//}
//
//void  enqueue(elemType key,queue* q){
//	struct node* item =(struct node*)malloc(sizeof(struct node));
//	if(item == NULL){
//		printf("can not allocate memory!");
//		exit(1);
//	}
//	item->value=key;
//	item->next=NULL;
//	if(isEmpty(q)){
//		q->head=q->rear=item;
//	}else{
//		q->rear->next=item;
//		q->rear=item;
//	}
//	return ;
//}
//
//elemType dequeue(queue* q){//free the useless space
//	elemType res;
//	struct node * tmp;
//	if(q->head == NULL){
//		printf("the queue is empty!");
//		exit(1);
//	}else{
//		res=q->head->value;
//		tmp=q->head;
//		q->head=tmp->next;
//		if(q->head ==NULL){
//			q->rear=NULL;
//		}
//		free(tmp);
//		return res;
//	}
//}
//
//void clearQueue(queue *q){
//	struct node  *tmp=q->head;
//	while(tmp!=NULL){
//		q->head=tmp->next;
//		free(tmp);
//		tmp=q->head;
//	}
//	q->rear=NULL;
//	return;
//}
//
